Extensibility is generally a requirement in modern software applications. In the context of business applications extensibility is a common selection criteria from a customer perspective. Therefore, software providers seek to provide support for extensibility to meet customer needs. However, there are some challenges that face software developers with respect to the specification and enforcement of extension possibilities of their software. The term extension interface typically refers to the extension possibilities offered by a software application. More specifically, an extension interface defines the resources of a base application that are allowed to be extended, how the software application is extended (e.g., on the programming level), what resources of the base application an extension developer and/or extension object is allowed to access, as well as where and when the extension code will run.
While concepts for such interfaces are a considered with regard to “traditional” software which is constructed using a single programming language. However, extension interfaces are completely missing for complex applications consisting of several abstraction or architectural layers. In addition, state-of-the-art approaches are limited with respect to the specification of extension interfaces. Further, extension interfaces do not support providing different extension interfaces for different stakeholders. Furthermore, the software provider has to manually provide the code that is responsible for providing an extension interface. This code is typically mixed with the functional code of the application, which limits the quality of the software and makes software maintenance difficult.
Accordingly, typical approaches for specifying and enforcing extension interfaces for software systems have at least the following problems. First, typical approaches provide a one-size-fits-all extension interface. In typical approaches, specifying different extension interfaces for different groups of extension developers and/or extension objects is typically not possible. Second, typical approaches do not support the multi-layered nature of software applications, which involve multiple layers and multiple artifacts on these layers (e.g. UI models, business process models, code artifacts, database tables, etc.). All existing approaches express extension possibilities on the technical code layer although an extension typically spans several layers. As a result, an extension developer and/or extension object cannot assess the feasibility of a simple UI form extension or a business process extension without diving deeply into the implementation layer and going through documentation materials and tutorials for some provided Application Programming Interface (API).
Third, typical approaches lack declarative means to specify the allowed extension possibilities and their types for the different artifacts of the base application (e.g. new methods, attributes, UI elements, process artifacts, new columns in a database table, and the like). Fourth, when supporting extensibility on different layers, it is necessary to capture the dependencies between the extension possibilities available on these layers. In fact, tools are needed to express dependencies such as if the extension developer and/or extension object adds a new field of some UI form then the extension developer and/or extension object also needs to extend the respective Java class with a new attribute and the respective database table with a new column. The inter-layer dependencies impose constraints on the way extension possibilities are expressed and also on the way an extension is developed.
Fifth, typical approaches lack tools to specify how to extend (e.g., on the programming level) the base software. Sixth, existing approaches lack tools to express what artifacts or data of the core software can be accessed by the extension developer and/or extension object and the respective access rights (e.g., giving access to, limiting access to and/or preventing access to software assets). This covers, for example, the definition of class attributes of the core software application that are visible to the extension developer and/or extension object as well as methods that can be called by the extension developer and/or extension object when writing code for an extension. Finally, typical approaches do not specify when and where the extension code will be run (e.g., if the extension code be executed before or after some method of the base application).
Some approaches manually implement an extension interface through coding without specifying such interface explicitly. For example, the software provider can decide the interfaces or abstract classes for use as entry points for the extension developer and/or extension object. However, the support (e.g., loading and executing the code implementing these extension artifacts) may be manually implemented by the software provider. In this way, the technical realization of the extension interface gets coupled with the functional code of the base software. This manual approach increases the application complexity and makes software maintenance more difficult. As a result, the extensibility rationale, intents, and decisions taken by the application provider get lost.
Further, in this manual approach, the extension interfaces are not explicit in definition. As a result, the software provider may have difficulty (e.g., without a comprehensive and up-to-date documentation) finding the exact methods, classes, and interfaces that make-up the extension interface. In addition, an extension developer will have a hard time identifying the extension interface and the extension possibilities as they are not expressed explicitly. Instead, the extension developer will have to read documentation and tutorials and to understand the whole provided APIs to assess the feasibility of some extension scenario. This gets even more difficult as the functional API of the application and its extensibility API are mixed.
Accordingly, there is a need to address the aforementioned problems by introducing a system and a method for specifying and enforcing extension interfaces in multilayered software applications.